// 一维数组展开函数
// 方法1: 外部函数+内部递归辅助函数
function flattenArray(arr) {
  // 创建一个空数组来存储结果
  const result = [];
  
  // 定义一个递归函数来处理嵌套数组
  function flatten(element) {
    // 如果元素不是数组，直接添加到结果中
    if (!Array.isArray(element)) {
      result.push(element);
    } else {
      // 如果元素是数组，递归处理每个元素
      for (let i = 0; i < element.length; i++) {
        flatten(element[i]);
      }
    }
  }
  
  // 对输入数组执行递归展开操作
  flatten(arr);
  
  return result;
}

// 方法2: ES6简化版本（使用reduce和递归）
function flattenArrayES6(arr) {
  return arr.reduce((acc, curr) => {
    return acc.concat(Array.isArray(curr) ? flattenArrayES6(curr) : curr);
  }, []);
}

// 方法3: 用户提供的实现（直接递归+concat）
function flatten(arr) {
  let result = [];
  for (let i = 0; i < arr.length; i++) {
    const item = arr[i];
    if (Array.isArray(item)) {
      result = result.concat(flatten(item));
    } else {
      result.push(item);
    }
  }
  return result;
}

// 使用示例
const nestedArray = [1, [2, [3, 4, 5]], 6, [7]];
const flatArray1 = flattenArray(nestedArray);
const flatArray2 = flattenArrayES6(nestedArray);
const flatArray3 = flatten(nestedArray);

console.log('原始嵌套数组:', nestedArray);
console.log('方法1 展开后的数组:', flatArray1);
console.log('方法2 展开后的数组:', flatArray2);
console.log('方法3 展开后的数组:', flatArray3);

/**
 * 三种实现方式的比较：
 * 
 * 1. 方法1 (flattenArray):
 *    - 优点：性能较好，只创建一个结果数组，使用push方法添加元素
 *    - 缺点：代码稍长，使用了嵌套函数
 *    - 适用场景：对性能要求较高的场景
 * 
 * 2. 方法2 (flattenArrayES6):
 *    - 优点：代码简洁，符合函数式编程风格
 *    - 缺点：每次递归都会创建新数组，性能较差
 *    - 适用场景：代码简洁性优先的场景
 * 
 * 3. 方法3 (用户提供的flatten):
 *    - 优点：实现直观，逻辑清晰
 *    - 缺点：每次递归调用concat都会创建新数组，性能较差
 *    - 适用场景：中小型数组或教学演示
 * 
 * 性能对比（从高到低）：方法1 > 方法3 > 方法2
 * 代码简洁度（从高到低）：方法2 > 方法3 > 方法1
 * 
 * 总结：如果数组很大或嵌套很深，推荐使用方法1；如果追求代码简洁，推荐使用方法2；用户提供的方法3在可读性和性能间取得了较好平衡。
 */

// 性能测试示例
function performanceTest() {
  console.log('\n--- 性能测试 ---');
  
  // 创建一个深度嵌套的测试数组
  const deepNested = Array(1000).fill().map((_, i) => {
    let arr = [i];
    let temp = arr;
    // 嵌套10层
    for (let j = 0; j < 10; j++) {
      temp = temp[0] = [i + j];
    }
    return arr;
  });
  
  // 测试方法1
  console.time('方法1');
  flattenArray(deepNested);
  console.timeEnd('方法1');
  
  // 测试方法2
  console.time('方法2');
  flattenArrayES6(deepNested);
  console.timeEnd('方法2');
  
  // 测试方法3
  console.time('方法3');
  flatten(deepNested);
  console.timeEnd('方法3');
}

// 运行性能测试
performanceTest();

// 其他测试用例
console.log('\n--- 边界情况测试 ---');
console.log('空数组测试:', flattenArray([]));
console.log('非嵌套数组测试:', flattenArray([1, 2, 3]));
console.log('深层嵌套测试:', flattenArray([[[[[1]]]]]));
console.log('混合类型测试:', flattenArray([1, 'hello', [true, null], {key: 'value'}]));